package reflection;

import pojo.User;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * 通过反射获取泛型信息
 */
public class Test05 {

    public void test01(Map<String, User> map, List<User> list) {
        System.out.println("test01");
    }

    public Map<String, User> test02() {
        System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        final Method method = Test05.class.getDeclaredMethod("test01", Map.class, List.class);
        //获得方法的参数值类型
        final Type[] genericParameterTypes = method.getGenericParameterTypes();
        Arrays.stream(genericParameterTypes)
                //在这里判断是不是一个结构化类型（Collection<T>）
                .filter(g -> {
                    System.out.println(g);
                    return g instanceof ParameterizedType;
                })
                //如果是一个结构化类型，就将真实类型提取出来（T）
                .map(g -> {
                    return ((ParameterizedType)g).getActualTypeArguments();
                })
                //由于提出出来的也是Type[]，这个stream就变成了Type[Type[]]类型
                //所以要在forEach中，再来一次forEach
                .forEach(gs ->{
                    Arrays.stream(gs).forEach(System.out::println);
                });


        System.out.println("===========================");
        final Method test02 = Test05.class.getMethod("test02");
        //获得方法的返回值类型
        final Type genericReturnType = test02.getGenericReturnType();
        System.out.println(genericReturnType);
        if(genericReturnType instanceof ParameterizedType){
            final Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            Arrays.stream(actualTypeArguments).forEach(System.out::println);
        }
    }
}
